/**
 * 
 */
package com.cn.practice.singleton;

/**
 * 单例模式-第二次练习
 * 单例模式就是系统只存在一个实例的设计模式，后面新建的对象都是直接获取到第一次新建的对象
 * @author zhangyang
 *
 */
public class SingletonPractice2 {
public static void main(String[] args) {
	System.out.println(sinletonEhan2.getInstance()==sinletonEhan2.getInstance());
}
}

/**
 * 饿汉式-静态变量
 * @author zhangyang
 *
 */
class sinletonEhan1{
	//私有化构造器
	private sinletonEhan1() {
		
	}
	//静态变量 类型为返回的类
	private static sinletonEhan1 instance=new sinletonEhan1();
	//公有的方法 返回这个静态变量
	public static sinletonEhan1 getInstance() {
		return instance;
	}
}

/**
 * 饿汉式-静态代码块
 * 类初始化的时候会执行和静态变量一样
 * @author zhangyang
 *
 */
class sinletonEhan2{
	//私有化构造器
	private sinletonEhan2() {
		
	}
	//静态变量 类型为返回的类
	private static sinletonEhan2 instance;
	
	static {
		instance=new sinletonEhan2();
	}
	//公有的方法 返回这个静态变量
	public static sinletonEhan2 getInstance() {
		return instance;
	}
}

/**
 * 懒汉式-线程不安全 不能使用多线程环境判断空逻辑有问题
 * @author zhangyang
 *
 */
class singletonLanhan1{
	//私有化构造器
	private singletonLanhan1() {
		
	}
	//静态变量 类型为返回的类
	private static singletonLanhan1 instance;
	
	//公有的方法 返回这个静态变量
	public static singletonLanhan1 getInstance() {
		if(instance==null) {
			instance=new singletonLanhan1();
		}
		return instance;
	}
}

/**
 * 懒汉式-线程安全 
 * 是非线程安全的改进方法加入了synchronized
 * synchronized加入效率太低 
 * @author zhangyang
 *
 */
class singletonLanhan2{
	//私有化构造器
	private singletonLanhan2() {
		
	}
	//静态变量 类型为返回的类
	private static singletonLanhan2 instance;
	
	//公有的方法 返回这个静态变量
	public static  synchronized singletonLanhan2 getInstance() {
		if(instance==null) {
			instance=new singletonLanhan2();
		}
		return instance;
	}
} 

/**
 * 双重检查 推荐使用既保证延迟加载有保证线程安全
 * 是线程安全的改进 使用了volatile和synchronized两个关键字
 * @author zhangyang
 *
 */
class singletonDoubleCheck {
	//私有化构造器
	private singletonDoubleCheck() {
		
	}
	//静态变量 类型为返回的类
	private static volatile singletonDoubleCheck instance;
	
	public static singletonDoubleCheck getInstance() {
		if(instance==null) {
			//锁住singletonDoubleCheck类保证进入逻辑是线程安全的
			synchronized(singletonDoubleCheck.class) {
				if(instance==null) {
					instance=new singletonDoubleCheck();
				}
			}
		}
		return instance;
	}
		
}

/**
 * 静态内部类 推荐使用 
 * 使用了静态内部类的特性延迟加载 由于类的加载机制 所以是线程安全的
 * @author zhangyang
 *
 */
class singletonStaticInnerClass{
	//私有化构造器
	private singletonStaticInnerClass() {
		
	}
	//静态内部类 里面定义一个返回值类型的对象
	private static class innerClass{
		static singletonStaticInnerClass instance=new singletonStaticInnerClass();
	}
	//公有方法返回静态内部类中的对象
	public singletonStaticInnerClass getInstance() {
		return innerClass.instance;
	}
}
//枚举